home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_100 / 105_01 / long.c < prev    next >
Encoding:
C/C++ Source or Header  |  1984-06-03  |  5.8 KB  |  234 lines
  1. /*                LONG INTEGER PACKAGE
  2.  
  3.       The functions below, together with the Z-80 assembly
  4.     language coded routine li, constitute a package to
  5.     provide long integer capability to BDS C via function
  6.     calls similar to those provided by Bob Mathias'
  7.     floating point package.
  8.  
  9.       Note that, while the functions below are portable,
  10.     the basic workhorse function in the backage, li, will
  11.     only run on a Z-80 processor.  Further, li assumes that
  12.     the BDS C version 1.4x stack conventions are being used.
  13.  
  14.       The Long Integer Package and the function li were
  15.     programmed by Paul J. Gans, Department of Chemistry,
  16.     New York University, New York, NY  10003.  Phone
  17.     (212) 598-2515 9 am to 5 pm.
  18.  
  19.       Please let me know about bugs, problems, improvements,
  20.     or what you will.  That's the only way things will
  21.     get better.
  22.  
  23.       BDS C is copyright 1980 by Leor Zolman.
  24.  
  25.       Version record:
  26.  
  27.     Version 1.0    March 6, 1981        Original version.
  28.  
  29.       The Long Integer Package and the function li are
  30.     copyright (c) 1981 by Paul J. Gans.
  31.  
  32.  
  33. */
  34.  
  35. #define   ADD     0
  36. #define   SUB     1
  37. #define   MUL     2
  38. #define   DIV     3
  39. #define   MOD     4
  40.  
  41. /*   ladd adds the addend and augend to produce a 32 bit
  42.    signed result in sum.  A pointer to sum is returned.  */
  43.  
  44. char *ladd(sum,addend,augend)
  45. char sum[], addend[], augend[];
  46. {
  47.     char *li();
  48.  
  49.     return (li(ADD,sum,addend,augend));
  50. }
  51.  
  52. /*   lsub subtracts subtrahend from minuend and places the
  53.    32 bit signed difference in difference.  A pointer to
  54.    difference is returned.                              */
  55.  
  56. char *lsub(difference,minuend,subtrahend)
  57. char difference[], minuend[], subtrahend[];
  58. {
  59.     char *li();
  60.  
  61.     return (li(SUB,difference,minuend,subtrahend));
  62. }
  63.  
  64. /*   lmul multiplies plier and plicand together and places
  65.    the signed low order 32 bit product in product.  A
  66.    pointer to product is returned.                      */
  67.  
  68. char *lmul(product,plier,plicand)
  69. char product[], plier[], plicand[];
  70. {
  71.     char *li();
  72.  
  73.     return (li(MUL,product,plier,plicand));
  74. }
  75.  
  76. /*   ldiv divides dividend by divisor and places the signed
  77.    low order 32 bits of the quotient in quotient.  A
  78.    pointer to quotient is returned.                   */
  79.  
  80. char *ldiv(quotient,dividend,divisor)
  81. char quotient[], dividend[], divisor[];
  82. {
  83.     char *li();
  84.  
  85.     return (li(DIV,quotient,dividend,divisor));
  86. }
  87.  
  88. /*   lmod places the 31 bit positive remainder resulting
  89.    from the division of dividend by divisor into residue.
  90.    A pointer to residue is returned.                   */
  91.  
  92. char *lmod(residue,dividend,divisor)
  93. char residue[], dividend[], divisor[];
  94. {
  95.     char *li();
  96.  
  97.     return (li(MOD,residue,dividend,divisor));
  98. }
  99.  
  100. /*   lneg places the 32 bit signed negative of orignum in
  101.    negnum and returns a pointer to it.                  */
  102.  
  103. char *lneg(negnum,orignum)
  104. char negnum[], orignum[];
  105. {
  106.     char *li(), work[4], i;
  107.  
  108.     for (i=0; i<4; ++i) work[i]=0;
  109.     return (li(SUB,negnum,work,orignum));
  110. }
  111.  
  112. /*   itol converts an integer to long form.  A pointer
  113.    to the longform is returned.                       */
  114.  
  115. char *itol(longform,i)
  116. char longform[];
  117. int i;
  118. {
  119.     longform[3]=longform[2]=0;
  120.     if (i<0) longform[3]=longform[2]=0xff;
  121.     longform[1]=i>>8;
  122.     longform[0]=i&0xff;
  123.     return longform;
  124. }
  125.  
  126. /*   ltoi returns a properly signed integer containing the
  127.    low order 15 bits of precision of the long integer
  128.     longint.  The value of this integer is placed in i and
  129.    is returned by this function.                         */
  130.  
  131. ltoi(i,longint)
  132. char longint[4];
  133. int i;
  134. {
  135.     char work[4];
  136.  
  137.     for (i=0; i<4; ++i) work[i]=longint[i];
  138.     if (work[3]>127) lneg(work,work);
  139.     i=(work[1]<<8)+work[0];
  140.     if (longint[3]>127) i=-i;
  141.     return i;
  142. }
  143.  
  144. /*   atol converts the ASCII string s to a long integer
  145.    placed in longint and returns a pointer to longint.
  146.    Acceptable format for atol is:  any amount of white
  147.    space followed by an optional sign followed by a string
  148.    of decimal digits.  The first non-decimal digit stops
  149.    the scan.  The method used is an adaptation of that
  150.    presented in Kernighan and Ritchie.                */
  151.  
  152. char *atol(longint,s)
  153. char longint[], s[];
  154. {
  155.     char work[4], ten[4];
  156.     int i, j, n, sign;
  157.  
  158.     /* form a constant.. */
  159.  
  160.     ten[0]=0x0a; ten[1]=ten[2]=ten[3]=0;
  161.     /*   first skip white space... */
  162.  
  163.     for (i=0; s[i]==' ' || s[i]=='\n' || s[i]=='\t'; i++);
  164.  
  165.     /*   now get the sign... */
  166.  
  167.     sign=1;
  168.     if (s[i]=='+' || s[i]=='-')
  169.         sign=(s[i++]=='+') ? 1 : -1;
  170.  
  171.     /*   and convert the string straightforwardly... */
  172.  
  173.     for (j=0; j<4; ++j) longint[j]=0;
  174.     while (s[i]>='0' && s[i]<='9') {
  175.         for (j=0; j<4; ++j) work[j]=0;
  176.         work[0]=s[i++]-'0';
  177.         lmul(longint,ten,longint);
  178.         ladd(longint,longint,work);
  179.     }
  180.  
  181.     /*   not forgetting the original sign... */
  182.  
  183.     if (sign==-1) lneg(longint,longint);
  184.     return longint;
  185. }
  186.  
  187. /*   ltoa converts the long integer longint to an ASCII
  188.    string which is placed in s.  If longint is negative a
  189.    minus sign is prefixes the string.  The algorithm used
  190.    is an adaptation of itoa presented in Kernighan and
  191.    Ritchie.                                          */
  192.  
  193. ltoa(s,longint)
  194. char s[], longint[];
  195. {
  196.     char c, work[4], ten[4];
  197.     int i, j, k, sign;
  198.  
  199.     ten[0]=0x0a; ten[1]=ten[2]=ten[3]=0;
  200.     sign=1;
  201.  
  202.     /*   check the sign... */
  203.  
  204.     if (longint[3]>127) {
  205.         sign=-1;
  206.         lneg(longint,longint);
  207.     }
  208.  
  209.     /*   convert, generating digits backwards in s[]... */
  210.  
  211.     i=0;
  212.     do {
  213.         lmod(work,longint,ten);
  214.         s[i++]=work[0]+'0';
  215.         ldiv(longint,longint,ten);
  216.     } while ((longint[0]|longint[1]|longint[2]|
  217.         longint[3])!=0);
  218.  
  219.     /*   postfix a minus sign if needed... */
  220.  
  221.     if (sign==-1) s[i++]='-';
  222.     s[i]='\0';
  223.  
  224.     /*   and turn the whole thing around in place. */
  225.  
  226.     k=strlen(s);
  227.     for (i=0, j=k-1; i<j; i++, j--) {
  228.         c=s[i]; s[i]=s[j]; s[j]=c;
  229.     }
  230.  
  231.     return s;
  232. }
  233. 
  234. Lèç